/**
 * MongoDB 服务模块（基于连接池）
 * @author HalRui
 * @version 1.0.0
 * @description 基于连接池的MongoDB服务，提供数据库连接管理、健康检查和统计信息等功能
 * @date 2025年9月27日
 */

/**
 * MongoDB 服务（基于连接池）
 * 使用连接池管理 MongoDB 连接
 */

const connectionPool = require('./connection-pool');
const mongoose = require('mongoose');

class MongoService {
    constructor() {
        this.connectionPool = connectionPool;
    }

    /**
     * 获取 MongoDB 连接
     */
    getConnection() {
        return this.connectionPool.getMongoConnection();
    }

    /**
     * 获取 Mongoose 连接实例
     */
    getMongooseConnection() {
        return mongoose.connection;
    }

    /**
     * 检查连接状态
     */
    isConnected() {
        const status = this.connectionPool.getConnectionStatus();
        return status.mongodb.connected;
    }

    /**
     * 获取数据库统计信息
     */
    async getStats() {
        try {
            const connection = this.getConnection();
            const db = connection.db;
            const stats = await db.stats();
            return stats;
        } catch (error) {
            console.error('获取数据库统计信息失败:', error);
            throw error;
        }
    }

    /**
     * 获取集合列表
     */
    async getCollections() {
        try {
            const connection = this.getConnection();
            const db = connection.db;
            const collections = await db.listCollections().toArray();
            return collections.map(col => col.name);
        } catch (error) {
            console.error('获取集合列表失败:', error);
            throw error;
        }
    }

    /**
     * 执行数据库命令
     */
    async runCommand(command) {
        try {
            const connection = this.getConnection();
            const db = connection.db;
            const result = await db.command(command);
            return result;
        } catch (error) {
            console.error('执行数据库命令失败:', error);
            throw error;
        }
    }

    /**
     * 健康检查
     */
    async healthCheck() {
        try {
            const start = Date.now();
            await mongoose.connection.db.admin().ping();
            const latency = Date.now() - start;
            
            return {
                status: 'healthy',
                latency: latency,
                host: mongoose.connection.host,
                port: mongoose.connection.port,
                name: mongoose.connection.name
            };
        } catch (error) {
            console.error('MongoDB 健康检查失败:', error);
            return {
                status: 'unhealthy',
                error: error.message
            };
        }
    }

    /**
     * 获取连接池统计信息
     */
    async getPoolStats() {
        try {
            const connection = this.getConnection();
            const client = mongoose.connection.client;
            
            if (client && client.topology && client.topology.s && client.topology.s.pool) {
                const pool = client.topology.s.pool;
                return {
                    size: pool.size || 0,
                    available: pool.available || 0,
                    borrowed: pool.borrowed || 0,
                    pending: pool.pending || 0,
                    maxPoolSize: pool.options?.maxPoolSize || 10,
                    minPoolSize: pool.options?.minPoolSize || 2
                };
            } else {
                // 返回默认的连接池信息
                return {
                    size: 0,
                    available: 0,
                    borrowed: 0,
                    pending: 0,
                    maxPoolSize: 10,
                    minPoolSize: 2,
                    note: '连接池信息不可用，返回默认值'
                };
            }
        } catch (error) {
            console.error('获取连接池统计信息失败:', error);
            return {
                error: error.message,
                note: '获取连接池统计信息时发生错误'
            };
        }
    }

    // 向后兼容的方法
    static async connect() {
        console.warn('⚠️ MongoService.connect() 已被弃用，请使用连接池自动管理');
        return connectionPool.getMongoConnection();
    }

    static async disconnect() {
        console.warn('⚠️ MongoService.disconnect() 已被弃用，连接池会自动管理连接生命周期');
        // 不执行任何操作，由连接池管理
    }

    static async autoConnect(callback) {
        console.warn('⚠️ MongoService.autoConnect() 已被弃用，连接池会自动管理连接');
        if (typeof callback === 'function') {
            return await callback();
        }
        throw new Error('传递参数不是一个函数');
    }
}

module.exports = MongoService;
